SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Concurrent computing</title>

</head>

<span id="openzim-page-title" class="mw-page-title-main"><span class="mw-page-title-main">Concurrent computing</span></span>

</h1>

</header>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable">For the American computer company, see <a href="Concurrent_Computer_Corporation" title="Concurrent Computer Corporation">Concurrent Computer Corporation</a>. For a more theoretical discussion, see <a href="Concurrency_(computer_science)" title="Concurrency (computer science)">Concurrency (computer science)</a>.</div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .ambox{border:1px solid #a2a9b1;border-left:10px solid #36c;background-color:#fbfbfb;box-sizing:border-box}.mw-parser-output .ambox+link+.ambox,.mw-parser-output .ambox+link+style+.ambox,.mw-parser-output .ambox+link+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+style+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+link+.ambox{margin-top:-1px}html body.mediawiki .mw-parser-output .ambox.mbox-small-left{margin:4px 1em 4px 0;overflow:hidden;width:238px;border-collapse:collapse;font-size:88%;line-height:1.25em}.mw-parser-output .ambox-speedy{border-left:10px solid #b32424;background-color:#fee7e6}.mw-parser-output .ambox-delete{border-left:10px solid #b32424}.mw-parser-output .ambox-content{border-left:10px solid #f28500}.mw-parser-output .ambox-style{border-left:10px solid #fc3}.mw-parser-output .ambox-move{border-left:10px solid #9932cc}.mw-parser-output .ambox-protection{border-left:10px solid #a2a9b1}.mw-parser-output .ambox .mbox-text{border:none;padding:0.25em 0.5em;width:100%}.mw-parser-output .ambox .mbox-image{border:none;padding:2px 0 2px 0.5em;text-align:center}.mw-parser-output .ambox .mbox-imageright{border:none;padding:2px 0.5em 2px 0;text-align:center}.mw-parser-output .ambox .mbox-empty-cell{border:none;padding:0;width:1px}.mw-parser-output .ambox .mbox-image-div{width:52px}@media(min-width:720px){.mw-parser-output .ambox{margin:0 10%}}@media print{body.ns-0 .mw-parser-output .ambox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style>

<p><b>Concurrent computing</b> is a form of <a href="Computing" title="Computing">computing</a> in which several <a href="Computation" title="Computation">computations</a> are executed <i><a href="Concurrency_(computer_science)" title="Concurrency (computer science)">concurrently</a></i>—during overlapping time periods—instead of <i>sequentially—</i>with one completing before the next starts.

</p><p>This is a property of a system—whether a <a href="Computer_program" title="Computer program">program</a>, <a href="Computer" title="Computer">computer</a>, or a <a href="Computer_network" title="Computer network">network</a>—where there is a separate execution point or "thread of control" for each process. A <i>concurrent system</i> is one where a computation can advance without waiting for all other computations to complete.<sup id="cite_ref-1" class="reference"><a href="#cite_note-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>

</p><p>Concurrent computing is a form of <a href="Modular_programming" title="Modular programming">modular programming</a>. In its <a href="Programming_paradigm" title="Programming paradigm">paradigm</a> an overall computation is <a href="Decomposition_(computer_science)" title="Decomposition (computer science)">factored</a> into subcomputations that may be executed concurrently. Pioneers in the field of concurrent computing include <a href="Edsger_Dijkstra" class="mw-redirect" title="Edsger Dijkstra">Edsger Dijkstra</a>, <a href="Per_Brinch_Hansen" title="Per Brinch Hansen">Per Brinch Hansen</a>, and <a href="C.A.R._Hoare" class="mw-redirect" title="C.A.R. Hoare">C.A.R. Hoare</a>.<sup id="cite_ref-2" class="reference"><a href="#cite_note-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup>

</p>

<div class="mw-heading mw-heading2"><h2 id="Introduction">Introduction</h2></div>

<div role="note" class="hatnote navigation-not-searchable">See also: <a href="Parallel_computing" title="Parallel computing">Parallel computing</a></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .multiple-issues-text{width:95%;margin:0.2em 0}.mw-parser-output .multiple-issues-text>.mw-collapsible-content{margin-top:0.3em}.mw-parser-output .compact-ambox .ambox{border:none;border-collapse:collapse;background-color:transparent;margin:0 0 0 1.6em!important;padding:0!important;width:auto;display:block}body.mediawiki .mw-parser-output .compact-ambox .ambox.mbox-small-left{font-size:100%;width:auto;margin:0}.mw-parser-output .compact-ambox .ambox .mbox-text{padding:0!important;margin:0!important}.mw-parser-output .compact-ambox .ambox .mbox-text-span{display:list-item;line-height:1.5em;list-style-type:disc}body.skin-minerva .mw-parser-output .multiple-issues-text>.mw-collapsible-toggle,.mw-parser-output .compact-ambox .ambox .mbox-image,.mw-parser-output .compact-ambox .ambox .mbox-imageright,.mw-parser-output .compact-ambox .ambox .mbox-empty-cell,.mw-parser-output .compact-ambox .hide-when-compact{display:none}

/* end https://en.wikipedia.org/ */

</style>

<p>The concept of concurrent computing is frequently confused with the related but distinct concept of <a href="Parallel_computing" title="Parallel computing">parallel computing</a>,<sup id="cite_ref-waza_3-0" class="reference"><a href="#cite_note-waza-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-4" class="reference"><a href="#cite_note-4"><span class="cite-bracket">[</span>4<span class="cite-bracket">]</span></a></sup> although both can be described as "multiple processes executing <i>during the same period of time</i>". In parallel computing, execution occurs at the same physical instant: for example, on separate <a href="Central_processing_unit" title="Central processing unit">processors</a> of a <a href="Multi-processor" class="mw-redirect" title="Multi-processor">multi-processor</a> machine, with the goal of speeding up computations—parallel computing is impossible on a (<a href="Multi-core_processor" title="Multi-core processor">one-core</a>) single processor, as only one computation can occur at any instant (during any single clock cycle).<sup id="cite_ref-5" class="reference"><a href="#cite_note-5"><span class="cite-bracket">[</span>a<span class="cite-bracket">]</span></a></sup> By contrast, concurrent computing consists of process <i>lifetimes</i> overlapping, but execution does not happen at the same instant. The goal here is to model processes that happen concurrently, like multiple clients accessing a server at the same time. Structuring software systems as composed of multiple concurrent, communicating parts can be useful for tackling complexity, regardless of whether the parts can be executed in parallel.<sup id="cite_ref-6" class="reference"><a href="#cite_note-6"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup><sup class="reference nowrap"><span title="Page / location: 1">: 1 </span></sup>

</p><p>For example, concurrent processes can be executed on one core by interleaving the execution steps of each process via <a href="Time-sharing" title="Time-sharing">time-sharing</a> slices: only one process runs at a time, and if it does not complete during its time slice, it is <i>paused</i>, another process begins or resumes, and then later the original process is resumed. In this way, multiple processes are part-way through execution at a single instant, but only one process is being executed at that instant.

</p><p>Concurrent computations <i>may</i> be executed in parallel,<sup id="cite_ref-waza_3-1" class="reference"><a href="#cite_note-waza-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-benari2006_7-0" class="reference"><a href="#cite_note-benari2006-7"><span class="cite-bracket">[</span>6<span class="cite-bracket">]</span></a></sup> for example, by assigning each process to a separate processor or processor core, or <a href="Distributed_computing" title="Distributed computing">distributing</a> a computation across a network.

</p><p>The exact timing of when tasks in a concurrent system are executed depends on the <a href="Scheduling_(computing)" title="Scheduling (computing)">scheduling</a>, and tasks need not always be executed concurrently. For example, given two tasks, T1 and T2:

</p>

<ul><li>T1 may be executed and finished before T2 or <i>vice versa</i> (serial <i>and</i> sequential)</li>

<li>T1 and T2 may be executed alternately (serial <i>and</i> concurrent)</li>

<li>T1 and T2 may be executed simultaneously at the same instant of time (parallel <i>and</i> concurrent)</li></ul>

<p>The word "sequential" is used as an antonym for both "concurrent" and "parallel"; when these are explicitly distinguished, <i>concurrent/sequential</i> and <i>parallel/serial</i> are used as opposing pairs.<sup id="cite_ref-FOOTNOTEPattersonHennessy2013503_8-0" class="reference"><a href="#cite_note-FOOTNOTEPattersonHennessy2013503-8"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup> A schedule in which tasks execute one at a time (serially, no parallelism), without interleaving (sequentially, no concurrency: no task begins until the prior task ends) is called a <i>serial schedule</i>. A set of tasks that can be scheduled serially is <i><a href="Serializability" class="mw-redirect" title="Serializability">serializable</a></i>, which simplifies <a href="Concurrency_control" title="Concurrency control">concurrency control</a>.

</p>

<div class="mw-heading mw-heading3"><h3 id="Coordinating_access_to_shared_resources">Coordinating access to shared resources</h3></div>

<p>The main challenge in designing concurrent programs is <a href="Concurrency_control" title="Concurrency control">concurrency control</a>: ensuring the correct sequencing of the interactions or communications between different computational executions, and coordinating access to resources that are shared among executions.<sup id="cite_ref-benari2006_7-1" class="reference"><a href="#cite_note-benari2006-7"><span class="cite-bracket">[</span>6<span class="cite-bracket">]</span></a></sup> Potential problems include <a href="Race_condition#Software" title="Race condition">race conditions</a>, <a href="Deadlock_(computer_science)" title="Deadlock (computer science)">deadlocks</a>, and <a href="Resource_starvation" class="mw-redirect" title="Resource starvation">resource starvation</a>. For example, consider the following algorithm to make withdrawals from a checking account represented by the shared resource <code>balance</code>:

</p>

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr mw-highlight-lines" dir="ltr"><pre><span class="kt">bool</span><span class="w"> </span><span class="nf">withdraw</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">withdrawal</span><span class="p">)</span>

<span class="hll"><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">balance</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="n">withdrawal</span><span class="p">)</span>

</span><span class="w"> </span><span class="p">{</span>

<span class="hll"><span class="w"> </span><span class="n">balance</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="n">withdrawal</span><span class="p">;</span>

</span><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">true</span><span class="p">;</span>

<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">false</span><span class="p">;</span>

</pre></div>

<p>Suppose <code>balance = 500</code>, and two concurrent <i>threads</i> make the calls <code>withdraw(300)</code> and <code>withdraw(350)</code>. If line 3 in both operations executes before line 5 both operations will find that <code>balance >= withdrawal</code> evaluates to <code>true</code>, and execution will proceed to subtracting the withdrawal amount. However, since both processes perform their withdrawals, the total amount withdrawn will end up being more than the original balance. These sorts of problems with shared resources benefit from the use of concurrency control, or <a href="Non-blocking_algorithm" title="Non-blocking algorithm">non-blocking algorithms</a>.

</p>

<div class="mw-heading mw-heading3"><h3 id="Advantages">Advantages</h3></div>

<p>There are advantages of concurrent computing:

</p>

<ul><li>Increased program throughput—parallel execution of a concurrent algorithm allows the number of tasks completed in a given time to increase proportionally to the number of processors according to <a href="Gustafson's_law" title="Gustafson's law">Gustafson's law</a>.<sup id="cite_ref-9" class="reference"><a href="#cite_note-9"><span class="cite-bracket">[</span>8<span class="cite-bracket">]</span></a></sup></li>

<li>High responsiveness for input/output—input/output-intensive programs mostly wait for input or output operations to complete. Concurrent programming allows the time that would be spent waiting to be used for another task.<sup id="cite_ref-10" class="reference"><a href="#cite_note-10"><span class="cite-bracket">[</span>9<span class="cite-bracket">]</span></a></sup></li>

<li>More appropriate program structure—some problems and problem domains are well-suited to representation as concurrent tasks or processes. For example <a href="Multiversion_concurrency_control" title="Multiversion concurrency control">MVCC</a>.</li></ul>

<div class="mw-heading mw-heading2"><h2 id="Models">Models</h2></div>

<p>Introduced in 1962, <a href="Petri_net" title="Petri net">Petri nets</a> were an early attempt to codify the rules of concurrent execution. Dataflow theory later built upon these, and <a href="Dataflow_architecture" title="Dataflow architecture">Dataflow architectures</a> were created to physically implement the ideas of dataflow theory. Beginning in the late 1970s, <a href="Process_calculi" class="mw-redirect" title="Process calculi">process calculi</a> such as <a href="Calculus_of_Communicating_Systems" class="mw-redirect" title="Calculus of Communicating Systems">Calculus of Communicating Systems</a> (CCS) and <a href="Communicating_Sequential_Processes" class="mw-redirect" title="Communicating Sequential Processes">Communicating Sequential Processes</a> (CSP) were developed to permit algebraic reasoning about systems composed of interacting components. The <a href="Pi_calculus" class="mw-redirect" title="Pi calculus">π-calculus</a> added the capability for reasoning about dynamic topologies.

</p><p><a href="Input/output_automaton" title="Input/output automaton">Input/output automata</a> were introduced in 1987.

</p><p>Logics such as Lamport's <a href="Temporal_logic_of_actions" title="Temporal logic of actions">TLA+</a>, and mathematical models such as <a href="Trace_theory" title="Trace theory">traces</a> and <a href="Actor_model_theory" title="Actor model theory">Actor event diagrams</a>, have also been developed to describe the behavior of concurrent systems.

</p><p><a href="Software_transactional_memory" title="Software transactional memory">Software transactional memory</a> borrows from <a href="Database_management_system" class="mw-redirect" title="Database management system">database theory</a> the concept of <a href="Atomic_commit" title="Atomic commit">atomic transactions</a> and applies them to memory accesses.

</p>

<div class="mw-heading mw-heading3"><h3 id="Consistency_models">Consistency models</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Consistency_model" title="Consistency model">Consistency model</a></div>

<p>Concurrent programming languages and multiprocessor programs must have a <a href="Consistency_model" title="Consistency model">consistency model</a> (also known as a memory model). The consistency model defines rules for how operations on <a href="Computer_data_storage" title="Computer data storage">computer memory</a> occur and how results are produced.

</p><p>One of the first consistency models was <a href="Leslie_Lamport" title="Leslie Lamport">Leslie Lamport</a>'s <a href="Sequential_consistency" title="Sequential consistency">sequential consistency</a> model. Sequential consistency is the property of a program that its execution produces the same results as a sequential program. Specifically, a program is sequentially consistent if "the results of any execution is the same as if the operations of all the processors were executed in some sequential order, and the operations of each individual processor appear in this sequence in the order specified by its program".<sup id="cite_ref-11" class="reference"><a href="#cite_note-11"><span class="cite-bracket">[</span>10<span class="cite-bracket">]</span></a></sup>

</p>

<div role="note" class="hatnote navigation-not-searchable">See also: <a href="Relaxed_sequential" title="Relaxed sequential">Relaxed sequential</a></div>

<div class="mw-heading mw-heading2"><h2 id="Implementation">Implementation</h2></div>

<p>A number of different methods can be used to implement concurrent programs, such as implementing each computational execution as an <a href="Process_(computer_science)" class="mw-redirect" title="Process (computer science)">operating system process</a>, or implementing the computational processes as a set of <a href="Thread_(computer_science)" class="mw-redirect" title="Thread (computer science)">threads</a> within a single operating system process.

</p>

<div class="mw-heading mw-heading3"><h3 id="Interaction_and_communication">Interaction and communication</h3></div>

<p>In some concurrent computing systems, communication between the concurrent components is hidden from the programmer (e.g., by using <a href="Future_(programming)" class="mw-redirect" title="Future (programming)">futures</a>), while in others it must be handled explicitly. Explicit communication can be divided into two classes:

</p>

<dl><dt>Shared memory communication</dt>

<dd>Concurrent components communicate by altering the contents of <a href="Shared_memory_(interprocess_communication)" class="mw-redirect" title="Shared memory (interprocess communication)">shared memory</a> locations (exemplified by <a href="Java_(programming_language)" title="Java (programming language)">Java</a> and <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a>). This style of concurrent programming usually needs the use of some form of locking (e.g., <a href="Mutual_exclusion" title="Mutual exclusion">mutexes</a>, <a href="Semaphore_(programming)" title="Semaphore (programming)">semaphores</a>, or <a href="Monitor_(synchronization)" title="Monitor (synchronization)">monitors</a>) to coordinate between threads. A program that properly implements any of these is said to be <a href="Thread_safety" title="Thread safety">thread-safe</a>.</dd></dl>

<dl><dt>Message passing communication</dt>

<dd>Concurrent components communicate by <a href="Message_passing" title="Message passing">message passing</a> (exchanging messages, exemplified by <a href="Open_MPI" title="Open MPI">MPI</a>, <a href="Go_(programming_language)" title="Go (programming language)">Go</a>, <a href="Scala_(programming_language)" title="Scala (programming language)">Scala</a>, <a href="Erlang_(programming_language)" title="Erlang (programming language)">Erlang</a> and <a href="Occam_(programming_language)" title="Occam (programming language)">occam</a>). The exchange of messages may be carried out asynchronously, or may use a synchronous "rendezvous" style in which the sender blocks until the message is received. Asynchronous message passing may be reliable or unreliable (sometimes referred to as "send and pray"). Message-passing concurrency tends to be far easier to reason about than shared-memory concurrency, and is typically considered a more robust form of concurrent programming. A wide variety of mathematical theories to understand and analyze message-passing systems are available, including the <a href="Actor_model" title="Actor model">actor model</a>, and various <a href="Process_calculi" class="mw-redirect" title="Process calculi">process calculi</a>. Message passing can be efficiently implemented via <a href="Symmetric_multiprocessing" title="Symmetric multiprocessing">symmetric multiprocessing</a>, with or without shared memory <a href="Cache_coherence" title="Cache coherence">cache coherence</a>.</dd></dl>

<p>Shared memory and message passing concurrency have different performance characteristics. Typically (although not always), the per-process memory overhead and task switching overhead is lower in a message passing system, but the overhead of message passing is greater than for a procedure call. These differences are often overwhelmed by other performance factors.

</p>

<div class="mw-heading mw-heading2"><h2 id="History">History</h2></div>

<p>Concurrent computing developed out of earlier work on railroads and <a href="Telegraphy" title="Telegraphy">telegraphy</a>, from the 19th and early 20th century, and some terms date to this period, such as semaphores. These arose to address the question of how to handle multiple trains on the same railroad system (avoiding collisions and maximizing efficiency) and how to handle multiple transmissions over a given set of wires (improving efficiency), such as via <a href="Time-division_multiplexing" title="Time-division multiplexing">time-division multiplexing</a> (1870s).

</p><p>The academic study of concurrent algorithms started in the 1960s, with <a href="#CITEREFDijkstra1965">Dijkstra (1965)</a> credited with being the first paper in this field, identifying and solving <a href="Mutual_exclusion" title="Mutual exclusion">mutual exclusion</a>.<sup id="cite_ref-12" class="reference"><a href="#cite_note-12"><span class="cite-bracket">[</span>11<span class="cite-bracket">]</span></a></sup>

</p>

<div class="mw-heading mw-heading2"><h2 id="Prevalence">Prevalence</h2></div>

<p>Concurrency is pervasive in computing, occurring from low-level hardware on a single chip to worldwide networks. Examples follow.

</p><p>At the programming language level:

</p>

<ul><li><a href="Channel_(programming)" title="Channel (programming)">Channel</a></li>

<li><a href="Coroutine" title="Coroutine">Coroutine</a></li>

<li><a href="Futures_and_promises" title="Futures and promises">Futures and promises</a></li></ul>

<p>At the operating system level:

</p>

<ul><li><a href="Computer_multitasking" title="Computer multitasking">Computer multitasking</a>, including both <a href="Cooperative_multitasking" title="Cooperative multitasking">cooperative multitasking</a> and <a href="Preemptive_multitasking" class="mw-redirect" title="Preemptive multitasking">preemptive multitasking</a>

<ul><li><a href="Time-sharing" title="Time-sharing">Time-sharing</a>, which replaced sequential <a href="Batch_processing" title="Batch processing">batch processing</a> of jobs with concurrent use of a system</li></ul></li>

<li><a href="Process_(computing)" title="Process (computing)">Process</a></li>

<li><a href="Thread_(computing)" title="Thread (computing)">Thread</a></li></ul>

<p>At the network level, networked systems are generally concurrent by their nature, as they consist of separate devices.

</p>

<div class="mw-heading mw-heading2"><h2 id="Languages_supporting_concurrent_programming">Languages supporting concurrent programming</h2></div>

<p><a href="List_of_concurrent_programming_languages" class="mw-redirect" title="List of concurrent programming languages">Concurrent programming languages</a> are programming languages that use language constructs for <a href="Concurrency_(computer_science)" title="Concurrency (computer science)">concurrency</a>. These constructs may involve <a href="Thread_(computer_science)" class="mw-redirect" title="Thread (computer science)">multi-threading</a>, support for <a href="Distributed_computing" title="Distributed computing">distributed computing</a>, <a href="Message_passing_programming" class="mw-redirect" title="Message passing programming">message passing</a>, <a href="Sharing" title="Sharing">shared resources</a> (including <a href="Parallel_Random_Access_Machine" class="mw-redirect" title="Parallel Random Access Machine">shared memory</a>) or <a href="Futures_and_promises" title="Futures and promises">futures and promises</a>. Such languages are sometimes described as <i>concurrency-oriented languages</i> or <i>concurrency-oriented programming languages</i> (COPL).<sup id="cite_ref-armstrong2003_13-0" class="reference"><a href="#cite_note-armstrong2003-13"><span class="cite-bracket">[</span>12<span class="cite-bracket">]</span></a></sup>

</p><p>Today, the most commonly used programming languages that have specific constructs for concurrency are <a href="Java_(programming_language)" title="Java (programming language)">Java</a> and <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a>. Both of these languages fundamentally use a shared-memory concurrency model, with locking provided by <a href="Monitor_(synchronization)" title="Monitor (synchronization)">monitors</a> (although message-passing models can and have been implemented on top of the underlying shared-memory model). Of the languages that use a message-passing concurrency model, <a href="Erlang_(programming_language)" title="Erlang (programming language)">Erlang</a> was probably the most widely used in industry as of 2010.

</p><p>Many concurrent programming languages have been developed more as research languages (e.g., <a href="Pict_(programming_language)" title="Pict (programming language)">Pict</a>) rather than as languages for production use. However, languages such as <a href="Erlang_(programming_language)" title="Erlang (programming language)">Erlang</a>, <a href="Limbo_(programming_language)" title="Limbo (programming language)">Limbo</a>, and <a href="Occam_(programming_language)" title="Occam (programming language)">occam</a> have seen industrial use at various times in the last 20 years. A non-exhaustive list of languages which use or provide concurrent programming facilities:

</p>

<ul><li><a href="Ada_(programming_language)" title="Ada (programming language)">Ada</a>—general purpose, with native support for message passing and monitor based concurrency</li>

<li><a href="Alef_(programming_language)" title="Alef (programming language)">Alef</a>—concurrent, with threads and message passing, for system programming in early versions of <a href="Plan_9_from_Bell_Labs" title="Plan 9 from Bell Labs">Plan 9 from Bell Labs</a></li>

<li><a href="Alice_(programming_language)" title="Alice (programming language)">Alice</a>—extension to <a href="Standard_ML" title="Standard ML">Standard ML</a>, adds support for concurrency via futures</li>

<li><a href="Ateji_PX" title="Ateji PX">Ateji PX</a>—extension to <a href="Java_(programming_language)" title="Java (programming language)">Java</a> with parallel primitives inspired from <a href="%CE%A0-calculus" title="Π-calculus">π-calculus</a></li>

<li><a href="Axum_(programming_language)" title="Axum (programming language)">Axum</a>—domain specific, concurrent, based on actor model and .NET Common Language Runtime using a C-like syntax</li>

<li><a href="BMDFM" class="mw-redirect" title="BMDFM">BMDFM</a>—Binary Modular DataFlow Machine</li>

<li><a href="C%2B%2B" title="C++">C++</a>—thread and coroutine support libraries<sup id="cite_ref-14" class="reference"><a href="#cite_note-14"><span class="cite-bracket">[</span>13<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-15" class="reference"><a href="#cite_note-15"><span class="cite-bracket">[</span>14<span class="cite-bracket">]</span></a></sup></li>

<li><a href="C%CF%89" class="mw-redirect" title="Cω">Cω</a> (C omega)—for research, extends C#, uses asynchronous communication</li>

<li><a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a>—supports concurrent computing using <style data-mw-deduplicate="TemplateStyles:r886049734">

/* start https://en.wikipedia.org/ */

.mw-parser-output .monospaced{font-family:monospace,monospace}

/* end https://en.wikipedia.org/ */

</style><span class="monospaced">lock</span>, <span class="monospaced">yield</span>, also since version 5.0 <span class="monospaced">async</span> and <span class="monospaced">await</span> keywords introduced</li>

<li><a href="Clojure" title="Clojure">Clojure</a>—modern, <a href="Functional_programming" title="Functional programming">functional programming</a> dialect of <a href="Lisp_(programming_language)" title="Lisp (programming language)">Lisp</a> on the <a href="Java_(software_platform)" title="Java (software platform)">Java</a> platform</li>

<li><a href="Concurrent_Clean" class="mw-redirect" title="Concurrent Clean">Concurrent Clean</a>—functional programming, similar to <a href="Haskell" title="Haskell">Haskell</a></li>

<li><a href="Concurrent_Collections" title="Concurrent Collections">Concurrent Collections</a> (CnC)—Achieves implicit parallelism independent of memory model by explicitly defining flow of data and control</li>

<li><a href="Concurrent_Haskell" title="Concurrent Haskell">Concurrent Haskell</a>—lazy, pure functional language operating concurrent processes on shared memory</li>

<li><a href="Concurrent_ML" title="Concurrent ML">Concurrent ML</a>—concurrent extension of <a href="Standard_ML" title="Standard ML">Standard ML</a></li>

<li><a href="Concurrent_Pascal" title="Concurrent Pascal">Concurrent Pascal</a>—by <a href="Per_Brinch_Hansen" title="Per Brinch Hansen">Per Brinch Hansen</a></li>

<li><a href="Curry_(programming_language)" title="Curry (programming language)">Curry</a></li>

<li><a href="D_(programming_language)" title="D (programming language)">D</a>—<a href="Multi-paradigm_programming_language" class="mw-redirect" title="Multi-paradigm programming language">multi-paradigm</a> <a href="System_programming_language" title="System programming language">system programming language</a> with explicit support for concurrent programming (<a href="Actor_model" title="Actor model">actor model</a>)</li>

<li><a href="E_(programming_language)" title="E (programming language)">E</a>—uses promises to preclude deadlocks</li>

<li><a href="ECMAScript" title="ECMAScript">ECMAScript</a>—uses promises for asynchronous operations</li>

<li><a href="Eiffel_(programming_language)" title="Eiffel (programming language)">Eiffel</a>—through its <a href="SCOOP_(software)" title="SCOOP (software)">SCOOP</a> mechanism based on the concepts of Design by Contract</li>

<li><a href="Elixir_(programming_language)" title="Elixir (programming language)">Elixir</a>—dynamic and functional meta-programming aware language running on the Erlang VM.</li>

<li><a href="Erlang_(programming_language)" title="Erlang (programming language)">Erlang</a>—uses synchronous or asynchronous message passing with no shared memory</li>

<li><a href="FAUST_(programming_language)" title="FAUST (programming language)">FAUST</a>—real-time functional, for signal processing, compiler provides automatic parallelization via <a href="OpenMP" title="OpenMP">OpenMP</a> or a specific <a href="Cilk#Work-stealing" title="Cilk">work-stealing</a> scheduler</li>

<li><a href="Fortran" title="Fortran">Fortran</a>—<a href="Coarray_Fortran" title="Coarray Fortran">coarrays</a> and <i>do concurrent</i> are part of Fortran 2008 standard</li>

<li><a href="Go_(programming_language)" title="Go (programming language)">Go</a>—for system programming, with a concurrent programming model based on <a href="Communicating_sequential_processes" title="Communicating sequential processes">CSP</a></li>

<li><a href="Haskell" title="Haskell">Haskell</a>—concurrent, and parallel functional programming language<sup id="cite_ref-16" class="reference"><a href="#cite_note-16"><span class="cite-bracket">[</span>15<span class="cite-bracket">]</span></a></sup></li>

<li><a href="Hume_(programming_language)" title="Hume (programming language)">Hume</a>—functional, concurrent, for bounded space and time environments where automata processes are described by synchronous channels patterns and message passing</li>

<li><a href="Io_(programming_language)" title="Io (programming language)">Io</a>—actor-based concurrency</li>

<li><a href="Janus_(concurrent_constraint_programming_language)" title="Janus (concurrent constraint programming language)">Janus</a>—features distinct <i>askers</i> and <i>tellers</i> to logical variables, bag channels; is purely declarative</li>

<li><a href="Java_(programming_language)" title="Java (programming language)">Java</a>—thread class or Runnable interface</li>

<li><a href="Julia_(programming_language)" title="Julia (programming language)">Julia</a>—"concurrent programming primitives: Tasks, async-wait, Channels."<sup id="cite_ref-17" class="reference"><a href="#cite_note-17"><span class="cite-bracket">[</span>16<span class="cite-bracket">]</span></a></sup></li>

<li><a href="JavaScript" title="JavaScript">JavaScript</a>—via <a href="Web_worker" title="Web worker">web workers</a>, in a browser environment, <a href="Futures_and_promises" title="Futures and promises">promises</a>, and <a href="Callback_(computer_programming)" title="Callback (computer programming)">callbacks</a>.</li>

<li><a href="JoCaml" title="JoCaml">JoCaml</a>—concurrent and distributed channel based, extension of <a href="OCaml" title="OCaml">OCaml</a>, implements the <a href="Join-calculus" title="Join-calculus">join-calculus</a> of processes</li>

<li><a href="Join_Java" class="mw-redirect" title="Join Java">Join Java</a>—concurrent, based on <a href="Java_(programming_language)" title="Java (programming language)">Java</a> language</li>

<li><a href="Joule_(programming_language)" title="Joule (programming language)">Joule</a>—dataflow-based, communicates by message passing</li>

<li><a href="Joyce_(programming_language)" title="Joyce (programming language)">Joyce</a>—concurrent, teaching, built on <a href="Concurrent_Pascal" title="Concurrent Pascal">Concurrent Pascal</a> with features from <a href="Communicating_sequential_processes" title="Communicating sequential processes">CSP</a> by <a href="Per_Brinch_Hansen" title="Per Brinch Hansen">Per Brinch Hansen</a></li>

<li><a href="LabVIEW" title="LabVIEW">LabVIEW</a>—graphical, dataflow, functions are nodes in a graph, data is wires between the nodes; includes object-oriented language</li>

<li><a href="Limbo_(programming_language)" title="Limbo (programming language)">Limbo</a>—relative of <a href="Alef_(programming_language)" title="Alef (programming language)">Alef</a>, for system programming in <a href="Inferno_(operating_system)" title="Inferno (operating system)">Inferno (operating system)</a></li>

<li><a href="Locomotive_BASIC" title="Locomotive BASIC">Locomotive BASIC</a>—Amstrad variant of BASIC contains EVERY and AFTER commands for concurrent subroutines</li>

<li><a href="MultiLisp" title="MultiLisp">MultiLisp</a>—<a href="Scheme_(programming_language)" title="Scheme (programming language)">Scheme</a> variant extended to support parallelism</li>

<li><a href="Modula-2" title="Modula-2">Modula-2</a>—for system programming, by N. Wirth as a successor to Pascal with native support for coroutines</li>

<li><a href="Modula-3" title="Modula-3">Modula-3</a>—modern member of Algol family with extensive support for threads, mutexes, condition variables</li>

<li><a href="Newsqueak" title="Newsqueak">Newsqueak</a>—for research, with channels as first-class values; predecessor of <a href="Alef_(programming_language)" title="Alef (programming language)">Alef</a></li>

<li><a href="Occam_(programming_language)" title="Occam (programming language)">occam</a>—influenced heavily by <a href="Communicating_sequential_processes" title="Communicating sequential processes">communicating sequential processes</a> (CSP)

<ul><li><a href="Occam-%CF%80" title="Occam-π">occam-π</a>—a modern variant of <a href="Occam_(programming_language)" title="Occam (programming language)">occam</a>, which incorporates ideas from Milner's <a href="%CE%A0-calculus" title="Π-calculus">π-calculus</a></li></ul></li>

<li><a href="Object_REXX" title="Object REXX">ooRexx</a>—object-based, message exchange for communication and synchronization</li>

<li><a href="Orc_(programming_language)" title="Orc (programming language)">Orc</a>—heavily concurrent, nondeterministic, based on <a href="Kleene_algebra" title="Kleene algebra">Kleene algebra</a></li>

<li><a href="Oz_(programming_language)" title="Oz (programming language)">Oz-Mozart</a>—multiparadigm, supports shared-state and message-passing concurrency, and futures</li>

<li><a href="ParaSail_(programming_language)" title="ParaSail (programming language)">ParaSail</a>—object-oriented, parallel, free of pointers, race conditions</li>

<li><a href="PHP" title="PHP">PHP</a>—multithreading support with parallel extension implementing message passing inspired from <a href="Go_(programming_language)" title="Go (programming language)">Go</a><sup id="cite_ref-18" class="reference"><a href="#cite_note-18"><span class="cite-bracket">[</span>17<span class="cite-bracket">]</span></a></sup></li>

<li><a href="Pict_(programming_language)" title="Pict (programming language)">Pict</a>—essentially an executable implementation of Milner's <a href="%CE%A0-calculus" title="Π-calculus">π-calculus</a></li>

<li><a href="Python_(programming_language)" title="Python (programming language)">Python</a> — uses thread-based parallelism and process-based parallelism <sup id="cite_ref-19" class="reference"><a href="#cite_note-19"><span class="cite-bracket">[</span>18<span class="cite-bracket">]</span></a></sup></li>

<li><a href="Raku_(programming_language)" title="Raku (programming language)">Raku</a> includes classes for threads, promises and channels by default<sup id="cite_ref-20" class="reference"><a href="#cite_note-20"><span class="cite-bracket">[</span>19<span class="cite-bracket">]</span></a></sup></li>

<li><a href="Reia_(programming_language)" class="mw-redirect" title="Reia (programming language)">Reia</a>—uses asynchronous message passing between shared-nothing objects</li>

<li><a href="Red_(programming_language)" title="Red (programming language)">Red/System</a>—for system programming, based on <a href="Rebol" title="Rebol">Rebol</a></li>

<li><a href="Rust_(programming_language)" title="Rust (programming language)">Rust</a>—for system programming, using message-passing with move semantics, shared immutable memory, and shared mutable memory.<sup id="cite_ref-bblum2012_21-0" class="reference"><a href="#cite_note-bblum2012-21"><span class="cite-bracket">[</span>20<span class="cite-bracket">]</span></a></sup></li>

<li><a href="Scala_(programming_language)" title="Scala (programming language)">Scala</a>—general purpose, designed to express common programming patterns in a concise, elegant, and type-safe way</li>

<li><a href="SequenceL" title="SequenceL">SequenceL</a>—general purpose functional, main design objectives are ease of programming, code clarity-readability, and automatic parallelization for performance on multicore hardware, and provably free of <a href="Race_condition" title="Race condition">race conditions</a></li>

<li><a href="SR_language" class="mw-redirect" title="SR language">SR</a>—for research</li>

<li><a href="SuperPascal" title="SuperPascal">SuperPascal</a>—concurrent, for teaching, built on <a href="Concurrent_Pascal" title="Concurrent Pascal">Concurrent Pascal</a> and <a href="Joyce_(programming_language)" title="Joyce (programming language)">Joyce</a> by <a href="Per_Brinch_Hansen" title="Per Brinch Hansen">Per Brinch Hansen</a></li>

<li><a href="Swift_(programming_language)" title="Swift (programming language)">Swift</a>—built-in support for writing asynchronous and parallel code in a structured way<sup id="cite_ref-22" class="reference"><a href="#cite_note-22"><span class="cite-bracket">[</span>21<span class="cite-bracket">]</span></a></sup></li>

<li><a href="Unicon_(programming_language)" title="Unicon (programming language)">Unicon</a>—for research</li>

<li><a href="TNSDL" title="TNSDL">TNSDL</a>—for developing telecommunication exchanges, uses asynchronous message passing</li>

<li>VHSIC Hardware Description Language (<a href="VHDL" title="VHDL">VHDL</a>)—IEEE STD-1076</li>

<li><a href="XC_(programming_language)" class="mw-redirect" title="XC (programming language)">XC</a>—concurrency-extended subset of C language developed by <a href="XMOS" title="XMOS">XMOS</a>, based on <a href="Communicating_sequential_processes" title="Communicating sequential processes">communicating sequential processes</a>, built-in constructs for programmable I/O</li></ul>

<p>Many other languages provide support for concurrency in the form of libraries, at levels roughly comparable with the above list.

</p>

<ul><li><a href="Asynchronous_I/O" title="Asynchronous I/O">Asynchronous I/O</a></li>

<li><a href="Chu_space" title="Chu space">Chu space</a></li>

<li><a href="Flow-based_programming" title="Flow-based programming">Flow-based programming</a></li>

<li><a href="Java_ConcurrentMap" title="Java ConcurrentMap">Java ConcurrentMap</a></li>

<li><a href="Ptolemy_Project" title="Ptolemy Project">Ptolemy Project</a></li>

<li><a href="Race_condition#Computing" title="Race condition">Race condition § Computing</a></li>

<li><a href="Structured_concurrency" title="Structured concurrency">Structured concurrency</a></li>

<li><a href="Transaction_processing" title="Transaction processing">Transaction processing</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="Notes">Notes</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist reflist-lower-alpha">

<li id="cite_note-5"><span class="mw-cite-backlink"><b><a href="#cite_ref-5">^</a></b></span> <span class="reference-text">This is discounting parallelism internal to a processor core, such as pipelining or vectorized instructions. A one-core, one-processor <i>machine</i> may be capable of some parallelism, such as with a <a href="Coprocessor" title="Coprocessor">coprocessor</a>, but the processor alone is not.</span>

</li>

</ol></div></div>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

<li id="cite_note-1"><span class="mw-cite-backlink"><b><a href="#cite_ref-1">^</a></b></span> <span class="reference-text"><i>Operating System Concepts</i> 9th edition, Abraham Silberschatz. "Chapter 4: Threads"</span>

</li>

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite id="CITEREFHansen2002" class="citation book cs1">Hansen, Per Brinch, ed. (2002). <a rel="nofollow" class="external text" href="https://link.springer.com/book/10.1007/978-1-4757-3472-0"><i>The Origin of Concurrent Programming</i></a>. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1007%2F978-1-4757-3472-0">10.1007/978-1-4757-3472-0</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-1-4419-2986-0</bdi>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:44909506">44909506</a>.</cite></span>

</li>

<li id="cite_note-waza-3"><span class="mw-cite-backlink">^ <a href="#cite_ref-waza_3-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-waza_3-1"><sup><i><b>b</b></i></sup></a></span> <span class="reference-text"><a href="Rob_Pike" title="Rob Pike">Pike, Rob</a> (2012-01-11). "Concurrency is not Parallelism". <i>Waza conference</i>, 11 January 2012. Retrieved from <a rel="nofollow" class="external free" href="https://talks.golang.org/2012/waza.slide">http://talks.golang.org/2012/waza.slide</a> (slides) and <a rel="nofollow" class="external free" href="https://vimeo.com/49718712">http://vimeo.com/49718712</a> (video).</span>

</li>

<li id="cite_note-4"><span class="mw-cite-backlink"><b><a href="#cite_ref-4">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://wiki.haskell.org/Parallelism_vs._Concurrency">"Parallelism vs. Concurrency"</a>. <i>Haskell Wiki</i>.</cite></span>

</li>

<li id="cite_note-6"><span class="mw-cite-backlink"><b><a href="#cite_ref-6">^</a></b></span> <span class="reference-text"><cite id="CITEREFSchneider1997" class="citation book cs1">Schneider, Fred B. (1997-05-06). <span class="id-lock-registration" title="Free registration required"><a rel="nofollow" class="external text" href="https://archive.org/details/onconcurrentprog0000schn"><i>On Concurrent Programming</i></a></span>. Springer. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>9780387949420</bdi>.</cite></span>

</li>

<li id="cite_note-benari2006-7"><span class="mw-cite-backlink">^ <a href="#cite_ref-benari2006_7-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-benari2006_7-1"><sup><i><b>b</b></i></sup></a></span> <span class="reference-text"><cite id="CITEREFBen-Ari2006" class="citation book cs1">Ben-Ari, Mordechai (2006). <i>Principles of Concurrent and Distributed Programming</i> (2nd ed.). Addison-Wesley. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0-321-31283-9</bdi>.</cite></span>

</li>

<li id="cite_note-FOOTNOTEPattersonHennessy2013503-8"><span class="mw-cite-backlink"><b><a href="#cite_ref-FOOTNOTEPattersonHennessy2013503_8-0">^</a></b></span> <span class="reference-text"><a href="#CITEREFPattersonHennessy2013">Patterson & Hennessy 2013</a>, p. 503.</span>

</li>

<li id="cite_note-9"><span class="mw-cite-backlink"><b><a href="#cite_ref-9">^</a></b></span> <span class="reference-text"><cite id="CITEREFPadua2011" class="citation book cs1">Padua, David (2011). <i>Encyclopedia of Parallel Computing</i>. Springer New York, NY (published September 8, 2011). pp. <span class="nowrap">819–</span>825. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0-387-09765-7</bdi>.</cite></span>

</li>

<li id="cite_note-10"><span class="mw-cite-backlink"><b><a href="#cite_ref-10">^</a></b></span> <span class="reference-text"><cite class="citation cs2"><a class="external text external" href="https://en.wikipedia.org/wiki/Asynchronous_I/O">"Asynchronous I/O"</a>, <i>Wikipedia</i>, 2024-12-20<span class="reference-accessdate">, retrieved <span class="nowrap">2024-12-27</span></span></cite></span>

</li>

<li id="cite_note-11"><span class="mw-cite-backlink"><b><a href="#cite_ref-11">^</a></b></span> <span class="reference-text"><cite id="CITEREFLamport1979" class="citation journal cs1">Lamport, Leslie (1 September 1979). "How to Make a Multiprocessor Computer That Correctly Executes Multiprocess Programs". <i>IEEE Transactions on Computers</i>. <b>C-28</b> (9): <span class="nowrap">690–</span>691. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1109%2FTC.1979.1675439">10.1109/TC.1979.1675439</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:5679366">5679366</a>.</cite></span>

</li>

<li id="cite_note-12"><span class="mw-cite-backlink"><b><a href="#cite_ref-12">^</a></b></span> <span class="reference-text"><cite class="citation report cs1"><a rel="nofollow" class="external text" href="http://www.podc.org/influential/2002.html">PODC Influential Paper Award: 2002</a>. <i>ACM Symposium on Principles of Distributed Computing</i> (Report)<span class="reference-accessdate">. Retrieved <span class="nowrap">2009-08-24</span></span>.</cite></span>

</li>

<li id="cite_note-armstrong2003-13"><span class="mw-cite-backlink"><b><a href="#cite_ref-armstrong2003_13-0">^</a></b></span> <span class="reference-text"><cite id="CITEREFArmstrong2003" class="citation web cs1">Armstrong, Joe (2003). <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160415213739/http://www.diva-portal.org/smash/get/diva2:9492/FULLTEXT01.pdf">"Making reliable distributed systems in the presence of software errors"</a> <span class="cs1-format">(PDF)</span>. Archived from <a rel="nofollow" class="external text" href="http://www.diva-portal.org/smash/get/diva2:9492/FULLTEXT01.pdf">the original</a> <span class="cs1-format">(PDF)</span> on 2016-04-15.</cite></span>

</li>

<li id="cite_note-14"><span class="mw-cite-backlink"><b><a href="#cite_ref-14">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://en.cppreference.com/w/cpp/header/thread">"Standard library header <thread> (C++11)"</a>. <i>en.cppreference.com</i><span class="reference-accessdate">. Retrieved <span class="nowrap">2024-10-03</span></span>.</cite></span>

</li>

<li id="cite_note-15"><span class="mw-cite-backlink"><b><a href="#cite_ref-15">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://en.cppreference.com/w/cpp/header/coroutine">"Standard library header <coroutine> (C++20)"</a>. <i>en.cppreference.com</i><span class="reference-accessdate">. Retrieved <span class="nowrap">2024-10-03</span></span>.</cite></span>

</li>

<li id="cite_note-16"><span class="mw-cite-backlink"><b><a href="#cite_ref-16">^</a></b></span> <span class="reference-text"> Marlow, Simon (2013) Parallel and Concurrent Programming in Haskell: Techniques for Multicore and Multithreaded Programming <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>9781449335946</bdi></span>

</li>

<li id="cite_note-17"><span class="mw-cite-backlink"><b><a href="#cite_ref-17">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20161018061906/https://juliacon.talkfunnel.com/2015/21-concurrent-and-parallel-programming-in-julia">"Concurrent and Parallel programming in Julia — JuliaCon India 2015 — HasGeek Talkfunnel"</a>. <i>juliacon.talkfunnel.com</i>. Archived from <a rel="nofollow" class="external text" href="https://juliacon.talkfunnel.com/2015/21-concurrent-and-parallel-programming-in-julia">the original</a> on 2016-10-18.</cite></span>

</li>

<li id="cite_note-18"><span class="mw-cite-backlink"><b><a href="#cite_ref-18">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.php.net/manual/en/book.parallel.php">"PHP: parallel - Manual"</a>. <i>www.php.net</i><span class="reference-accessdate">. Retrieved <span class="nowrap">2024-10-03</span></span>.</cite></span>

</li>

<li id="cite_note-19"><span class="mw-cite-backlink"><b><a href="#cite_ref-19">^</a></b></span> <span class="reference-text"><a rel="nofollow" class="external text" href="https://docs.python.org/3/library/concurrency.html">Documentation » The Python Standard Library » Concurrent Execution</a></span>

</li>

<li id="cite_note-20"><span class="mw-cite-backlink"><b><a href="#cite_ref-20">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://docs.perl6.org/language/concurrency">"Concurrency"</a>. <i>docs.perl6.org</i><span class="reference-accessdate">. Retrieved <span class="nowrap">2017-12-24</span></span>.</cite></span>

</li>

<li id="cite_note-bblum2012-21"><span class="mw-cite-backlink"><b><a href="#cite_ref-bblum2012_21-0">^</a></b></span> <span class="reference-text"><cite id="CITEREFBlum2012" class="citation web cs1">Blum, Ben (2012). <a rel="nofollow" class="external text" href="http://winningraceconditions.blogspot.com/2012/09/rust-4-typesafe-shared-mutable-state.html">"Typesafe Shared Mutable State"</a><span class="reference-accessdate">. Retrieved <span class="nowrap">2012-11-14</span></span>.</cite></span>

</li>

<li id="cite_note-22"><span class="mw-cite-backlink"><b><a href="#cite_ref-22">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://docs.swift.org/swift-book/LanguageGuide/Concurrency.html">"Concurrency"</a>. 2022<span class="reference-accessdate">. Retrieved <span class="nowrap">2022-12-15</span></span>.</cite></span>

</li>

</ol></div>

<div class="mw-heading mw-heading2"><h2 id="Sources">Sources</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .refbegin{margin-bottom:0.5em}.mw-parser-output .refbegin-hanging-indents>ul{margin-left:0}.mw-parser-output .refbegin-hanging-indents>ul>li{margin-left:0;padding-left:3.2em;text-indent:-3.2em}.mw-parser-output .refbegin-hanging-indents ul,.mw-parser-output .refbegin-hanging-indents ul li{list-style:none}@media(max-width:720px){.mw-parser-output .refbegin-hanging-indents>ul>li{padding-left:1.6em;text-indent:-1.6em}}.mw-parser-output .refbegin-columns{margin-top:0.3em}.mw-parser-output .refbegin-columns ul{margin-top:0}.mw-parser-output .refbegin-columns li{page-break-inside:avoid;break-inside:avoid-column}@media screen{.mw-parser-output .refbegin{font-size:90%}}

/* end https://en.wikipedia.org/ */

</style><div class="refbegin" style="">

<ul><li><cite id="CITEREFPattersonHennessy2013" class="citation book cs1">Patterson, David A.; Hennessy, John L. (2013). <i>Computer Organization and Design: The Hardware/Software Interface</i>. The Morgan Kaufmann Series in Computer Architecture and Design (5 ed.). Morgan Kaufmann. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0-12407886-4</bdi>.</cite></li></ul>

</div>

<div class="mw-heading mw-heading2"><h2 id="Further_reading">Further reading</h2></div>

<ul><li><cite id="CITEREFDijkstra1965" class="citation journal cs1"><a href="Edsger_W._Dijkstra" title="Edsger W. Dijkstra">Dijkstra, E. W.</a> (1965). <a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F365559.365617">"Solution of a problem in concurrent programming control"</a>. <i><a href="Communications_of_the_ACM" title="Communications of the ACM">Communications of the ACM</a></i>. <b>8</b> (9): 569. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<span class="id-lock-free" title="Freely accessible"><a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F365559.365617">10.1145/365559.365617</a></span>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:19357737">19357737</a>.</cite></li>

<li><cite id="CITEREFHerlihy2008" class="citation book cs1">Herlihy, Maurice (2008) [2008]. <i>The Art of Multiprocessor Programming</i>. Morgan Kaufmann. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0123705914</bdi>.</cite></li>

<li><cite id="CITEREFDowney2005" class="citation book cs1">Downey, Allen B. (2005) [2005]. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160304031330/http://www.greenteapress.com/semaphores/downey08semaphores.pdf"><i>The Little Book of Semaphores</i></a> <span class="cs1-format">(PDF)</span>. Green Tea Press. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-1-4414-1868-5</bdi>. Archived from <a rel="nofollow" class="external text" href="http://www.greenteapress.com/semaphores/downey08semaphores.pdf">the original</a> <span class="cs1-format">(PDF)</span> on 2016-03-04<span class="reference-accessdate">. Retrieved <span class="nowrap">2009-11-21</span></span>.</cite></li>

<li><cite id="CITEREFFilmanDaniel_P._Friedman1984" class="citation book cs1">Filman, Robert E.; Daniel P. Friedman (1984). <a rel="nofollow" class="external text" href="https://archive.org/details/coordinatedcompu0000film/page/370"><i>Coordinated Computing: Tools and Techniques for Distributed Software</i></a>. New York: McGraw-Hill. p. <a rel="nofollow" class="external text" href="https://archive.org/details/coordinatedcompu0000film/page/370">370</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0-07-022439-1</bdi>.</cite></li>

<li><cite id="CITEREFLeppäjärvi2008" class="citation book cs1">Leppäjärvi, Jouni (2008). <a rel="nofollow" class="external text" href="https://web.archive.org/web/20170830062719/http://www.enseignement.polytechnique.fr/informatique/INF431/X09-2010-2011/AmphiTHC/SynchronizationPrimitives.pdf"><i>A pragmatic, historically oriented survey on the universality of synchronization primitives</i></a> <span class="cs1-format">(PDF)</span>. University of Oulu. Archived from <a rel="nofollow" class="external text" href="http://www.enseignement.polytechnique.fr/informatique/INF431/X09-2010-2011/AmphiTHC/SynchronizationPrimitives.pdf">the original</a> <span class="cs1-format">(PDF)</span> on 2017-08-30<span class="reference-accessdate">. Retrieved <span class="nowrap">2012-09-13</span></span>.</cite></li>

<li><cite id="CITEREFTaubenfeld2006" class="citation book cs1">Taubenfeld, Gadi (2006). <a rel="nofollow" class="external text" href="http://www.faculty.idc.ac.il/gadi/book.htm"><i>Synchronization Algorithms and Concurrent Programming</i></a>. Pearson / Prentice Hall. p. 433. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0-13-197259-9</bdi>.</cite></li></ul>

<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>

<ul><li><span class="noviewer" typeof="mw:File"></span> Media related to <a href="https://commons.wikimedia.org/wiki/Category:Concurrent_programming" class="extiw external" title="commons:Category:Concurrent programming">Concurrent programming</a> at Wikimedia Commons</li>

<li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20060128114620/http://vl.fmnet.info/concurrent/">Concurrent Systems Virtual Library</a></li></ul>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hlist dl,.mw-parser-output .hlist ol,.mw-parser-output .hlist ul{margin:0;padding:0}.mw-parser-output .hlist dd,.mw-parser-output .hlist dt,.mw-parser-output .hlist li{margin:0;display:inline}.mw-parser-output .hlist.inline,.mw-parser-output .hlist.inline dl,.mw-parser-output .hlist.inline ol,.mw-parser-output .hlist.inline ul,.mw-parser-output .hlist dl dl,.mw-parser-output .hlist dl ol,.mw-parser-output .hlist dl ul,.mw-parser-output .hlist ol dl,.mw-parser-output .hlist ol ol,.mw-parser-output .hlist ol ul,.mw-parser-output .hlist ul dl,.mw-parser-output .hlist ul ol,.mw-parser-output .hlist ul ul{display:inline}.mw-parser-output .hlist .mw-empty-li{display:none}.mw-parser-output .hlist dt::after{content:": "}.mw-parser-output .hlist dd::after,.mw-parser-output .hlist li::after{content:" · ";font-weight:bold}.mw-parser-output .hlist dd:last-child::after,.mw-parser-output .hlist dt:last-child::after,.mw-parser-output .hlist li:last-child::after{content:none}.mw-parser-output .hlist dd dd:first-child::before,.mw-parser-output .hlist dd dt:first-child::before,.mw-parser-output .hlist dd li:first-child::before,.mw-parser-output .hlist dt dd:first-child::before,.mw-parser-output .hlist dt dt:first-child::before,.mw-parser-output .hlist dt li:first-child::before,.mw-parser-output .hlist li dd:first-child::before,.mw-parser-output .hlist li dt:first-child::before,.mw-parser-output .hlist li li:first-child::before{content:" (";font-weight:normal}.mw-parser-output .hlist dd dd:last-child::after,.mw-parser-output .hlist dd dt:last-child::after,.mw-parser-output .hlist dd li:last-child::after,.mw-parser-output .hlist dt dd:last-child::after,.mw-parser-output .hlist dt dt:last-child::after,.mw-parser-output .hlist dt li:last-child::after,.mw-parser-output .hlist li dd:last-child::after,.mw-parser-output .hlist li dt:last-child::after,.mw-parser-output .hlist li li:last-child::after{content:")";font-weight:normal}.mw-parser-output .hlist ol{counter-reset:listitem}.mw-parser-output .hlist ol>li{counter-increment:listitem}.mw-parser-output .hlist ol>li::before{content:" "counter(listitem)"\a0 "}.mw-parser-output .hlist dd ol>li:first-child::before,.mw-parser-output .hlist dt ol>li:first-child::before,.mw-parser-output .hlist li ol>li:first-child::before{content:" ("counter(listitem)"\a0 "}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1236075235">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbox{box-sizing:border-box;border:1px solid #a2a9b1;width:100%;clear:both;font-size:88%;text-align:center;padding:1px;margin:1em auto 0}.mw-parser-output .navbox .navbox{margin-top:0}.mw-parser-output .navbox+.navbox,.mw-parser-output .navbox+.navbox-styles+.navbox{margin-top:-1px}.mw-parser-output .navbox-inner,.mw-parser-output .navbox-subgroup{width:100%}.mw-parser-output .navbox-group,.mw-parser-output .navbox-title,.mw-parser-output .navbox-abovebelow{padding:0.25em 1em;line-height:1.5em;text-align:center}.mw-parser-output .navbox-group{white-space:nowrap;text-align:right}.mw-parser-output .navbox,.mw-parser-output .navbox-subgroup{background-color:#fdfdfd}.mw-parser-output .navbox-list{line-height:1.5em;border-color:#fdfdfd}.mw-parser-output .navbox-list-with-group{text-align:left;border-left-width:2px;border-left-style:solid}.mw-parser-output tr+tr>.navbox-abovebelow,.mw-parser-output tr+tr>.navbox-group,.mw-parser-output tr+tr>.navbox-image,.mw-parser-output tr+tr>.navbox-list{border-top:2px solid #fdfdfd}.mw-parser-output .navbox-title{background-color:#ccf}.mw-parser-output .navbox-abovebelow,.mw-parser-output .navbox-group,.mw-parser-output .navbox-subgroup .navbox-title{background-color:#ddf}.mw-parser-output .navbox-subgroup .navbox-group,.mw-parser-output .navbox-subgroup .navbox-abovebelow{background-color:#e6e6ff}.mw-parser-output .navbox-even{background-color:#f7f7f7}.mw-parser-output .navbox-odd{background-color:transparent}.mw-parser-output .navbox .hlist td dl,.mw-parser-output .navbox .hlist td ol,.mw-parser-output .navbox .hlist td ul,.mw-parser-output .navbox td.hlist dl,.mw-parser-output .navbox td.hlist ol,.mw-parser-output .navbox td.hlist ul{padding:0.125em 0}.mw-parser-output .navbox .navbar{display:block;font-size:100%}.mw-parser-output .navbox-title .navbar{float:left;text-align:left;margin-right:0.5em}body.skin--responsive .mw-parser-output .navbox-image img{max-width:none!important}@media print{body.ns-0 .mw-parser-output .navbox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style></div><div role="navigation" class="navbox" aria-labelledby="Concurrent_computing233" style="padding:3px"><table class="nowraplinks hlist mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><style data-mw-deduplicate="TemplateStyles:r1239400231">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbar{display:inline;font-size:88%;font-weight:normal}.mw-parser-output .navbar-collapse{float:left;text-align:left}.mw-parser-output .navbar-boxtext{word-spacing:0}.mw-parser-output .navbar ul{display:inline-block;white-space:nowrap;line-height:inherit}.mw-parser-output .navbar-brackets::before{margin-right:-0.125em;content:"[ "}.mw-parser-output .navbar-brackets::after{margin-left:-0.125em;content:" ]"}.mw-parser-output .navbar li{word-spacing:-0.125em}.mw-parser-output .navbar a>span,.mw-parser-output .navbar a>abbr{text-decoration:inherit}.mw-parser-output .navbar-mini abbr{font-variant:small-caps;border-bottom:none;text-decoration:none;cursor:inherit}.mw-parser-output .navbar-ct-full{font-size:114%;margin:0 7em}.mw-parser-output .navbar-ct-mini{font-size:114%;margin:0 4em}html.skin-theme-clientpref-night .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}@media(prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}}@media print{.mw-parser-output .navbar{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div id="Concurrent_computing233" style="font-size:114%;margin:0 4em"></div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%">General</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Concurrency_(computer_science)" title="Concurrency (computer science)">Concurrency</a></li>

<li><a href="Concurrency_control" title="Concurrency control">Concurrency control</a></li>

<li><a href="Concurrent_data_structure" title="Concurrent data structure">Concurrent data structures</a>

<ul><li><a href="Concurrent_hash_table" title="Concurrent hash table">Concurrent hash tables</a></li></ul></li>

<li><a href="Concurrent_user" title="Concurrent user">Concurrent users</a></li>

<li><a href="Indeterminacy_in_concurrent_computation" title="Indeterminacy in concurrent computation">Indeterminacy</a></li>

<li><a href="Linearizability" title="Linearizability">Linearizability</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Process_calculus" title="Process calculus">Process calculi</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<li><a href="Language_Of_Temporal_Ordering_Specification" class="mw-redirect" title="Language Of Temporal Ordering Specification">LOTOS</a></li>

<li><a href="%CE%A0-calculus" title="Π-calculus">π-calculus</a></li>

<li><a href="Ambient_calculus" title="Ambient calculus">Ambient calculus</a></li>

<li><a href="API-Calculus" title="API-Calculus">API-Calculus</a></li>

<li><a href="Join-calculus" title="Join-calculus">Join-calculus</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Classic problems</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="ABA_problem" title="ABA problem">ABA problem</a></li>

<li><a href="Cigarette_smokers_problem" title="Cigarette smokers problem">Cigarette smokers problem</a></li>

<li><a href="Deadlock_(computer_science)" title="Deadlock (computer science)">Deadlock</a></li>

<li><a href="Dining_philosophers_problem" title="Dining philosophers problem">Dining philosophers problem</a></li>

<li><a href="Producer%E2%80%93consumer_problem" title="Producer–consumer problem">Producer–consumer problem</a></li>

<li><a href="Race_condition" title="Race condition">Race condition</a></li>

<li><a href="Readers%E2%80%93writers_problem" title="Readers–writers problem">Readers–writers problem</a></li>

<li><a href="Sleeping_barber_problem" title="Sleeping barber problem">Sleeping barber problem</a></li></ul>

</div></td></tr><tr><td class="navbox-abovebelow" colspan="2"><div>

<ul><li><span class="noviewer" typeof="mw:File"><span title="Category"></span></span> Category: Concurrent computing</li></ul>

</div></td></tr></tbody></table></div>

<div class="navbox-styles"></div><div role="navigation" class="navbox" aria-labelledby="Programming_paradigms_(Comparison_by_language)368" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Programming_paradigms_(Comparison_by_language)368" style="font-size:114%;margin:0 4em"><a href="Programming_paradigm" title="Programming paradigm">Programming paradigms</a> (<a href="Comparison_of_multi-paradigm_programming_languages" title="Comparison of multi-paradigm programming languages">Comparison by language</a>)</div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Imperative_programming" title="Imperative programming">Imperative</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Structured_programming" title="Structured programming">Structured</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Jackson_structured_programming" title="Jackson structured programming">Jackson structures</a></li>

<li><a href="Block_(programming)" title="Block (programming)">Block-structured</a></li>

<li><a href="Modular_programming" title="Modular programming">Modular</a></li>

<li><a href="Non-structured_programming" title="Non-structured programming">Non-structured</a></li>

<li><a href="Procedural_programming" title="Procedural programming">Procedural</a></li>

<li><a href="Programming_in_the_large_and_programming_in_the_small" title="Programming in the large and programming in the small">Programming in the large and in the small</a></li>

<li><a href="Design_by_contract" title="Design by contract">Design by contract</a></li>

<li><a href="Invariant-based_programming" title="Invariant-based programming">Invariant-based</a></li>

<li><a href="Nested_function" title="Nested function">Nested function</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Object-oriented_programming" title="Object-oriented programming">Object-oriented</a><br>(<a href="Comparison_of_programming_languages_(object-oriented_programming)" title="Comparison of programming languages (object-oriented programming)">comparison</a>, <a href="List_of_object-oriented_programming_languages" title="List of object-oriented programming languages">list</a>)</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Class-based_programming" title="Class-based programming">Class-based</a>, <a href="Prototype-based_programming" title="Prototype-based programming">Prototype-based</a>, <a href="Object-based_language" title="Object-based language">Object-based</a></li>

<li><a href="Agent-oriented_programming" title="Agent-oriented programming">Agent</a></li>

<li><a href="Immutable_object" title="Immutable object">Immutable object</a></li>

<li><a href="Persistent_programming_language" title="Persistent programming language">Persistent</a></li>

<li><a href="Uniform_function_call_syntax" title="Uniform function call syntax">Uniform function call syntax</a></li></ul>

</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Declarative_programming" title="Declarative programming">Declarative</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Functional_programming" title="Functional programming">Functional</a><br>(<a href="Comparison_of_functional_programming_languages" title="Comparison of functional programming languages">comparison</a>)</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Recursion_(computer_science)" title="Recursion (computer science)">Recursive</a></li>

<li><a href="Anonymous_function" title="Anonymous function">Anonymous function</a> (<a href="Partial_application" title="Partial application">Partial application</a>)</li>

<li><a href="Higher-order_programming" title="Higher-order programming">Higher-order</a></li>

<li><a href="Purely_functional_programming" title="Purely functional programming">Purely functional</a></li>

<li><a href="Total_functional_programming" title="Total functional programming">Total</a></li>

<li><a href="Strict_programming_language" title="Strict programming language">Strict</a></li>

<li><a href="Generalized_algebraic_data_type" title="Generalized algebraic data type">GADTs</a></li>

<li><a href="Dependent_type" title="Dependent type">Dependent types</a></li>

<li><a href="Functional_logic_programming" title="Functional logic programming">Functional logic</a></li>

<li><a href="Tacit_programming" title="Tacit programming">Point-free style</a></li>

<li><a href="Expression-oriented_programming_language" title="Expression-oriented programming language">Expression-oriented</a></li>

<li><a href="Applicative_programming_language" title="Applicative programming language">Applicative</a>, <a href="Concatenative_programming_language" title="Concatenative programming language">Concatenative</a></li>

<li><a href="Function-level_programming" title="Function-level programming">Function-level</a>, <a href="Value-level_programming" title="Value-level programming">Value-level</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Dataflow_programming" title="Dataflow programming">Dataflow</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Flow-based_programming" title="Flow-based programming">Flow-based</a></li>

<li><a href="Reactive_programming" title="Reactive programming">Reactive</a> (<a href="Functional_reactive_programming" title="Functional reactive programming">Functional reactive</a>)</li>

<li><a href="Signal_programming" class="mw-redirect" title="Signal programming">Signals</a></li>

<li><a href="Stream_processing" title="Stream processing">Streams</a></li>

<li><a href="Synchronous_programming_language" title="Synchronous programming language">Synchronous</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Logic_programming" title="Logic programming">Logic</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Abductive_logic_programming" title="Abductive logic programming">Abductive logic</a></li>

<li><a href="Answer_set_programming" title="Answer set programming">Answer set</a></li>

<li><a href="Constraint_programming" title="Constraint programming">Constraint</a> (<a href="Constraint_logic_programming" title="Constraint logic programming">Constraint logic</a>)</li>

<li><a href="Inductive_logic_programming" title="Inductive logic programming">Inductive logic</a></li>

<li><a href="Nondeterministic_programming" title="Nondeterministic programming">Nondeterministic</a></li>

<li><a href="Ontology_language" title="Ontology language">Ontology</a></li>

<li><a href="Probabilistic_logic_programming" title="Probabilistic logic programming">Probabilistic logic</a></li>

<li><a href="Query_language" title="Query language">Query</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Domain-specific_language" title="Domain-specific language">DSL</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Algebraic_modeling_language" title="Algebraic modeling language">Algebraic modeling</a></li>

<li><a href="Array_programming" title="Array programming">Array</a></li>

<li><a href="Automata-based_programming" title="Automata-based programming">Automata-based</a> (<a href="Action_language" title="Action language">Action</a>)</li>

<li><a href="Command_language" title="Command language">Command</a> (<a href="Spacecraft_command_language" title="Spacecraft command language">Spacecraft</a>)</li>

<li><a href="Differentiable_programming" title="Differentiable programming">Differentiable</a></li>

<li><a href="Grammar-oriented_programming" title="Grammar-oriented programming">Grammar-oriented</a></li>

<li><a href="Interface_description_language" title="Interface description language">Interface description</a></li>

<li><a href="Language-oriented_programming" title="Language-oriented programming">Language-oriented</a></li>

<li><a href="List_comprehension" title="List comprehension">List comprehension</a></li>

<li><a href="Modeling_language" title="Modeling language">Modeling</a></li>

<li><a href="Natural-language_programming" class="mw-redirect" title="Natural-language programming">Natural language</a></li>

<li><a href="Non-English-based_programming_languages" title="Non-English-based programming languages">Non-English-based</a></li>

<li><a href="Page_description_language" title="Page description language">Page description</a></li>

<li><a href="Pipeline_(software)" title="Pipeline (software)">Pipes</a> and <a href="Filter_(software)" title="Filter (software)">filters</a></li>

<li><a href="Probabilistic_programming" title="Probabilistic programming">Probabilistic</a></li>

<li><a href="Quantum_programming" title="Quantum programming">Quantum</a></li>

<li><a href="Scientific_programming_language" title="Scientific programming language">Scientific</a></li>

<li><a href="Scripting_language" title="Scripting language">Scripting</a></li>

<li><a href="Set_theoretic_programming" title="Set theoretic programming">Set-theoretic</a></li>

<li><a href="Simulation_language" title="Simulation language">Simulation</a></li>

<li><a href="Stack-oriented_programming" title="Stack-oriented programming">Stack-based</a></li>

<li><a href="System_programming_language" title="System programming language">System</a></li>

<li><a href="Tactile_programming_language" title="Tactile programming language">Tactile</a></li>

<li><a href="Template_processor" title="Template processor">Templating</a></li>

<li><a href="Transformation_language" title="Transformation language">Transformation</a> (<a href="Graph_rewriting" title="Graph rewriting">Graph rewriting</a>, <a href="Production_system_(computer_science)" title="Production system (computer science)">Production</a>, <a href="Pattern_matching" title="Pattern matching">Pattern</a>)</li>

<li><a href="Visual_programming_language" title="Visual programming language">Visual</a></li></ul>

</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">,<br><a href="Distributed_computing" title="Distributed computing">distributed</a>,<br><a href="Parallel_computing" title="Parallel computing">parallel</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Actor_model" title="Actor model">Actor-based</a></li>

<li><a href="Automatic_mutual_exclusion" title="Automatic mutual exclusion">Automatic mutual exclusion</a></li>

<li><a href="Choreographic_programming" title="Choreographic programming">Choreographic programming</a></li>

<li><a href="Concurrent_logic_programming" title="Concurrent logic programming">Concurrent logic</a> (<a href="Concurrent_constraint_logic_programming" title="Concurrent constraint logic programming">Concurrent constraint logic</a>)</li>

<li><a href="Concurrent_object-oriented_programming" title="Concurrent object-oriented programming">Concurrent OO</a></li>

<li><a href="Macroprogramming" title="Macroprogramming">Macroprogramming</a></li>

<li><a href="Multitier_programming" title="Multitier programming">Multitier programming</a></li>

<li><a href="Organic_computing" title="Organic computing">Organic computing</a></li>

<li><a href="Parallel_programming_model" title="Parallel programming model">Parallel programming models</a></li>

<li><a href="Partitioned_global_address_space" title="Partitioned global address space">Partitioned global address space</a></li>

<li><a href="Process-oriented_programming" title="Process-oriented programming">Process-oriented</a></li>

<li><a href="Relativistic_programming" title="Relativistic programming">Relativistic programming</a></li>

<li><a href="Service-oriented_programming" title="Service-oriented programming">Service-oriented</a></li>

<li><a href="Structured_concurrency" title="Structured concurrency">Structured concurrency</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Metaprogramming" title="Metaprogramming">Metaprogramming</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Attribute-oriented_programming" title="Attribute-oriented programming">Attribute-oriented</a></li>

<li><a href="Automatic_programming" title="Automatic programming">Automatic</a> (<a href="Inductive_programming" title="Inductive programming">Inductive</a>)</li>

<li><a href="Dynamic_programming_language" title="Dynamic programming language">Dynamic</a></li>

<li><a href="Extensible_programming" title="Extensible programming">Extensible</a></li>

<li><a href="Generic_programming" title="Generic programming">Generic</a></li>

<li><a href="Homoiconicity" title="Homoiconicity">Homoiconicity</a></li>

<li><a href="Interactive_programming" title="Interactive programming">Interactive</a></li>

<li><a href="Macro_(computer_science)" title="Macro (computer science)">Macro</a> (<a href="Hygienic_macro" title="Hygienic macro">Hygienic</a>)</li>

<li><a href="Metalinguistic_abstraction" title="Metalinguistic abstraction">Metalinguistic abstraction</a></li>

<li><a href="Multi-stage_programming" title="Multi-stage programming">Multi-stage</a></li>

<li><a href="Program_synthesis" title="Program synthesis">Program synthesis</a> (<a href="Bayesian_program_synthesis" title="Bayesian program synthesis">Bayesian</a>, <a href="Inferential_programming" title="Inferential programming">Inferential</a>, <a href="Programming_by_demonstration" title="Programming by demonstration">by demonstration</a>, <a href="Programming_by_example" title="Programming by example">by example</a>)</li>

<li><a href="Reflective_programming" title="Reflective programming">Reflective</a></li>

<li><a href="Self-modifying_code" title="Self-modifying code">Self-modifying code</a></li>

<li><a href="Symbolic_programming" title="Symbolic programming">Symbolic</a></li>

<li><a href="Template_metaprogramming" title="Template metaprogramming">Template</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Separation_of_concerns" title="Separation of concerns">Separation<br>of concerns</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Aspect-oriented_programming" title="Aspect-oriented programming">Aspects</a></li>

<li><a href="Component-based_software_engineering" title="Component-based software engineering">Components</a></li>

<li><a href="Data-driven_programming" title="Data-driven programming">Data-driven</a></li>

<li><a href="Data-oriented_design" title="Data-oriented design">Data-oriented</a></li>

<li><a href="Event-driven_programming" title="Event-driven programming">Event-driven</a></li>

<li><a href="Feature-oriented_programming" title="Feature-oriented programming">Features</a></li>

<li><a href="Literate_programming" title="Literate programming">Literate</a></li>

<li><a href="Role-oriented_programming" title="Role-oriented programming">Roles</a></li>

<li><a href="Subject-oriented_programming" title="Subject-oriented programming">Subjects</a></li></ul>

</div></td></tr></tbody></table></div>

<div class="navbox-styles"></div><div role="navigation" class="navbox" aria-labelledby="Types_of_programming_languages107" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Types_of_programming_languages107" style="font-size:114%;margin:0 4em"><a href="Programming_paradigm" title="Programming paradigm">Types of programming languages</a></div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%">Level</th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Machine_code" title="Machine code">Machine</a></li>

<li><a href="Assembly_language" title="Assembly language">Assembly</a></li>

<li><a href="Compiled_language" title="Compiled language">Compiled</a></li>

<li><a href="Interpreted_language" class="mw-redirect" title="Interpreted language">Interpreted</a></li></ul>

<ul><li><a href="Low-level_programming_language" title="Low-level programming language">Low-level</a></li>

<li><a href="High-level_programming_language" title="High-level programming language">High-level</a></li>

<li><a href="Very_high-level_programming_language" title="Very high-level programming language">Very high-level</a></li>

<li><a href="Esoteric_programming_language" title="Esoteric programming language">Esoteric</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Programming_language_generations" title="Programming language generations">Generation</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="First-generation_programming_language" title="First-generation programming language">First</a></li>

<li><a href="Second-generation_programming_language" title="Second-generation programming language">Second</a></li>

<li><a href="Third-generation_programming_language" title="Third-generation programming language">Third</a></li>

<li><a href="Fourth-generation_programming_language" title="Fourth-generation programming language">Fourth</a></li>

<li><a href="Fifth-generation_programming_language" title="Fifth-generation programming language">Fifth</a></li></ul>

</div></td></tr></tbody></table></div></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-08-03" href="https://en.wikipedia.org/wiki/?title=Concurrent_computing&oldid=1303981981">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>